####################### Fonctions stub normalement fournies par Bertrand ###############################################

#Fonction bidon qui prends tout sur sdtin
proc receiveWhat {} {
	global fichier_lecture
	gets $fichier_lecture message
	return $message
}

#Fonction bidon qui place tout sur stdout
proc sendWhat {message} {
	global fichier_ecriture
	puts $fichier_ecriture $message
	flush $fichier_ecriture
}

##################### Fonctions de communication avancée pour l'application ###########################################

#Entrée : rien
#Sortie : un message reçu
#
#Comportement : appel la fonction de réception adéquate en fonction du message dans la file d'attente
proc recevoir {} {
	set message [receiveWhat]
	
	set type_message [lindex $message 0]
	if {$type_message == "ast"} {
		algo_reception_ast [recevoir_ast $message] 
	} elseif {$type_message == "joueur"} {
		algo_reception_joueurs [recevoir_joueur $message]
	} else {
		reception_destruction [recevoir_destruction $message]
	}
}

#Entrée : message, chaîne de caractères
#Sortie : message reçu, sous forme de liste
#
#Comportement : remet en forme le message astéroïde passé en argument en supprimant l'entête et en remettre en liste les joueurs
proc recevoir_ast {message} {
	set ast [lreplace $message 0 0]

	set liste_joueur [lrange $ast 8 end]
	
	set ast [lreplace $ast 8 end]
	
	lappend ast $liste_joueur
	
	return $ast
}

#Entrée : message, chaîne de caractères
#Sortie : message reçu, sous forme de liste
#
#Comportement : retire l'entête du message et estampille le message avec la date de réception
proc recevoir_joueur {message} {
	#supprime juste l'entête, le message est utilisable tel quel
	set joueur [lreplace $message 0 0]
	set_joueur_date joueur [clock seconds]
	return $joueur
}

#Entrée : message, châine de caractères
#Sortie : message , sous forme de liste à un seul élément
#
#Comportement : retire l'entête du message et transmet donc le numéro d'astéroïde
proc recevoir_destruction {message} {
	#supprimer juste l'entête du message de destruction
	return [lreplace $message 0 0]
}

#Entrée : une astéroïde, sous forme de liste
#Sortie : rien
#
#Comportement : à partir de l'astéroïde, formate une nouvelle liste et l'envoie sur le réseau
proc envoyer_ast {ast} {
	set nouvelle_liste {ast}
	for {set i 0} {$i < 8} {incr i} {
		lindex $ast $i
		lappend nouvelle_liste [lindex $ast $i]
	}
	set liste_joueur [lindex $ast 8]
	foreach i $liste_joueur {
		lappend nouvelle_liste $i
	}
	sendWhat $nouvelle_liste
}

#Entrée : un joueur, sous forme de liste
#Sortie : rien
#
#Comportement : à partir d'un joueur, formate une nouvelle liste et l'envoie sur le réseau
proc envoyer_joueur {joueur} {
	set joueur [linsert $joueur 0 "joueur"]
	sendWhat $joueur
}

proc envoyer_destruction {numero} {
	set message [linsert $numero 0 "destruction"]
    sendWhat $message
}
